Shareware Grab Bag/Shareware Grab Bag.iso/007/d86v311b.arc/BIOS.8

Text File | 1987-11-23 | 37KB | 901 lines

;---------------
;   BIOS module for the D86 debugger
;---------------

; Copyright (C)1987 Eric Isaacson.  All rights reserved.  Permission to
; copy and use this module is granted ONLY for machines registered for both
; the A86 assembler and the D86 debugger.

; Current support: IBM-PC, Wang PC, TI-PC, Sanyo 555, and Tandy 2000

; This module defines the BIOS interface for my D86 debugger.  I am publishing
; it to assist those who wish to assist me in implementing D86 on machines not
; BIOS-compatible with the IBM-PC.  To support a non-standard BIOS, we must
; provide new keyboard codes, new action routines, and several other data
; quantities.  The scenario for this is as follows:

; First, the debugger calls the procedure SET_MACHINE.    This procedure must
; detect what kind of machine it is running on, and set two variables:
;
;  * SUBDIR_CHAR, a byte giving the character that indicates a subdirectory for
;    an MS-DOS path name on your computer.  On an IBM-PC this is a backslash \
;    (e.g. a file name can be \usr\eric\foo.com); on a Wang this is an ordinary
;    backslash (e.g. the same file is /usr/eric/foo.com).
;
;  * BIOS_INIT, a pointer to a procedure that does BIOS-specific
;    initializations.
;
; Next, after performing some internal initializations, the debugger calls the
; BIOS_INIT routine.  That routine must do three things:
;
; 1. The routine must point SI to a special data structure (which I'll
;    describe shortly), then call the routine NEW_KEYS, to propagate the
;    items in the structure to the necessary places throughout the debugger.
;
; 2. The routine must perform any initializations necessary for this BIOS.
;    For example, WANG_CONFIG locates and stores the port number for hardware
;    that enables video access on the Wang.
;
; 3. The routine must decide if the debugger is running on the same screen as
;    the user program.  If it is, it must move the user's cursor to the lower
;    left corner of the screen.
;
; The structure fed to NEW_KEYS contains all the data necessary for ongoing
; debugger execution under the new BIOS.  See the structure WANG_KEYS for a
; prototype.  The structure consists of the following:
;
;  * a byte giving the keyboard code for the debugger's HELP key.
;
;  * a byte declaring the difference between your BIOS's key codes for
;    function keys, and the IBM BIOS's key codes.  Your BIOS_KEY must return
;    consecutive values for the function keys F1 through F10.  You should
;    declare this byte to be X - FUNC, where X is one less than the code
;    returned by the F1 key.  For example, since the Wang F1 key returns hex
;    080, the byte is declared 07F - FUNC.

;  * a number of bytes giving code values for all the other control keys
;    used by the debugger.  This list will be expanding with new versions;
;    see WANG_KEYS for the current version's list.  You should precede the list
;    with the L1 label, and follow it with the declaration N_CONTROL_KEYS EQU
;    $-L1, exactly as shown.  Don't change the name N_CONTROL_KEYS; the
;    redeclaration of the same name insures that you've gotten the right number
;    of codes into the table.
;
;  * a word pointing to a message string with the name of the help-key.  If your
;    keyboard has a key labelled HELP, use the name HELP_HELP as in WANG_KEYS.
;    If there is another key nonexistent on the IBM-PC (e.g. F11), then put
;    a new name (e.g. F11_HELP) following DW; I'll supply the definition for
;    the new name.  If there is no extra key and no HELP key, use Alt-F10 as
;    on the IBM-PC, and declare DW ALTF10_HELP here.
;
;  * the label L2: to be used to verify the number of following bytes.
;
;  * pointers to your BIOS's versions of the procedures VID_COPY, VID_ATTR,
;    VID_FIX, BIOS_BELL, and BIOS_KEY, described shortly. Substitute the name
;    of your machine for VID and BIOS in the generic names; e.g. the WANG_KEYS
;    structure has WANG_COPY, WANG_ATTR, WANG_BELL, and WANG_KEY.
;
;  * a word giving the segment register value for video memory on your machine.
;    The debugger will supply this value in the ES register when it calls
;    VID_COPY and VID_ATTR.  That is all the debugger does with it; so this
;    value can really be anything that the BIOS's versions of VID_COPY and
;    VID_ATTR want.
;
;  * a byte giving the attribute value for normal video.  This attribute will
;    be in effect for the entire debugger screen, except for the location of
;    the debugger's cursor.
;
;  * a byte giving the attribute value for reverse video.  This attribute will
;    be used to mark the debugger cursor.
;
;  * the declaration N_BIOS_CALLS EQU ($-L2)/2  Again, don't change the name;
;    the redeclaration of the name insures you didn't leave anything out.
;
; This completes the description of the structure fed to NEW_KEYS.  After
; BIOS_INIT is called, the debugger will keep calling 7 action routines to
; perform its interactive I/O.    The routines must perform actions as
; follows:

; VID_COPY copies CL bytes of characters from DS:SI to the video memory whose
;   location is given by ES:DI.  The characters should have the attribute
;   NORM_ATTR, which the caller will place into AH for VID_COPY's convenience.
;   VID_COPY must place the character byte and the attribute byte into each
;   output video word.    VID_COPY must return with BL preserved, the high byte
;   of SI preserved (it will be if you leave SI pointing beyond the bytes
;   copied), and DI advanced beyond the video memory just output.  The caller
;   assumes that video memory can be found at the value of VIDEO_SEG set by
;   BIOS_INIT, starting at offset 0, and proceeding consecutively, one 16-bit
;   memory word for every character.  The caller will set CH=0 for its first
;   call, so that VID_COPY can use CX as the count; but if it does, it must
;   return CH=0 for subsequent calls.

; VID_ATTR places the attribute byte AL into the video word whose location is
;   given by ES:DI.  The character byte of the video word must not be disturbed.

; VID_FIX restores a video screen that might have been clobbered by programs
;   external to the debugger.  If VID_COPY copies all characters to video memory
;   every time, then VID_FIX should RET without doing anything.  If, however,
;   VID_COPY tries to keep track of which characters are already on the screen,
;   and suppress video output for those that are, then VID_FIX should disable
;   the suppression feature, call the debugger's routine REFRESH to update the
;   whole screen, then re-enable the suppression feature.

; BIOS_BELL rings the bell.  NOTE that it is not acceptible for BIOS_BELL to
;   use the MS-DOS write routine to send a bell control-code to standard output;
;   if it did, then the debugger couldn't debug programs that have redirected
;   their standard output-- the bell code would go to the user program's output
;   file, and not be translated into a beep.

; BIOS_KEY returns in AL a code for a single keystroke.  The code should be
;   compatible with the values placed into the debugger's function tables by
;   BIOS_INIT.    If there is no keystroke available, BIOS_KEY should wait until
;   there is one.  BIOS_KEY should return on each individual key, and not wait
;   for any line-editing to take place.

; BIOS_SAVE saves whatever there is about the user program's BIOS state that
;   might be clobbered by the debugger.  Currently, the only such thing is
;   the user's cursor position on the Sanyo.  So on all machines but the Sanyo,
;   this is a "do-nothing" routine.

; BIOS_RESTORE restores the BIOS state saved by BIOS_SAVE.  Again, this routine
;   does nothing except on the Sanyo, on which it restores the user cursor
;   position, clobbered because D86 must use BIOS calls to write to the Sanyo
;   screen.

; SET_MACHINE determines what kind of machine we are running on, and sets
;   the variables SUBDIR_CHAR and BIOS_INIT accordingly.

TI_MSG_PTR  DD    0F400:0A022

TI_MSG:
            DB 'Texas I'
TI_MSG_LEN  EQU $-TI_MSG

TANDY_MSG1_PTR DD 0FC00:0002F      ; There are two BIOS versions for
TANDY_MSG2_PTR EQU 0032       ; the Tandy 2000 slightly different

TANDY_MSG:
            DB  'Tandy'
TANDY_MSG_LEN EQU $-TANDY_MSG

L2:            ; BH is not 1
  ADD BH,2        ; was BH 0FF?
  JNZ RET        ; return if not -- we are on an IBM-PC
  MOV ES,AX,0FFFF    ; it was-- address the end of ROM
  ES CMP AX,[6]         ; are there FFFF's beyond the boot-JMP?
  MOV AX,SANYO_CONFIG    ; load Sanyo address, in case there were
  JE >L1             ; jump if there were-- it is a Sanyo
  RET

SET_MACHINE:
  CMP DH,DH             ; set Z so a JMP can be patched into NOPS
  NOP                   ; you could patch a JMP to force a specific interface
  NOP
  LES DI,TI_MSG_PTR    ; point to the identifying message in the TI-PC ROM
  MOV SI,TI_MSG     ; point to our copy of that message
  MOV CX,TI_MSG_LEN    ; load the number of bytes that we have
  REPE CMPSB        ; is the message there in ROM?
  MOV AX,TIPC_CONFIG    ; load pointer to TI-PC's BIOS_INIT in case it is
  JE >L1        ; jump if it is, to store the pointer
  LES DI,TANDY_MSG1_PTR ; point to the identifying message in the T2K ROM
  MOV SI,TANDY_MSG    ; point to Tandy identifying message
  MOV CX,TANDY_MSG_LEN    ; length of message to compare
  PUSH SI,CX        ; save pointer+count in case we have to try other place
  REPE CMPSB        ; check for match in ROM header
  POP CX,SI        ; restore count and pointer
  MOV AX,TANDY_CONFIG    ; set pointer to Tandy 2000 BIOS_INIT
  JE >L1        ; jump and store pointer if we found it
  MOV DI,TANDY_MSG2_PTR ; point to second version message in the T2K ROM
  REPE CMPSB        ; check for match in ROM header
  JE >L1        ; jump and store pointer if we found it
  MOV AH,030        ; MS-DOS function number for VERSION
  INT 33        ; fetch the version; we want the machine code BH
  DEC BH        ; if BH was 1 we are on a Wang PC
  JNZ L2        ; variables already set if we are on an IBM-PC
  MOV SUBDIR_CHAR,'/'   ; subdirectory character on a Wang is /
  MOV AX,WANG_CONFIG    ; action routine for TI-PC is TIPC_CONFIG
L1:
  MOV BIOS_INIT,AX    ; store the action routine for this machine
  RET


; IBM_CONFIG is the BIOS_INIT routine for the IBM-PC.  Since its NEW_KEY
;   values are the defaults, we do not need to call NEW_KEY.

IBM_CONFIG:
  MOV AH,15          ; function number for GET_VIDEO_MODE
  INT 16          ; call the BIOS to get the mode
  CMP AL,7          ; are we in monochrome mode?
  MOV AX,0B000          ; load monochrome map location in case yes
  IF B MOV AH,0B8     ; if not then load color map location
  MOV BL,V_FLAG       ; load the setting of the -V switch
  XOR AH,BL          ; switch intefaces if we saw a -V in invocation
  CS MOV VIDEO_SEG,AX ; store the location of physical video
  TEST AH,8              ; are we on a CGA video board?
  JZ >L1              ; skip if not
  CS MOV VID_COPY,COLOR_COPY  ; we are: change the video-copy routine
  CS MOV BIOS_RESTORE,COLOR_RESTORE
  CS MOV REV_ATTR,0F0          ; change the reverse-video to blinking
L1:
  TEST BL          ; are we the same screen as the user program?
  JNZ RET          ; return if we are not-- no need to move cursor
SET_IBM_LOW_LEFT:
  MOV BH,0          ; page number is zero
  MOV DX,24 BY 0      ; we will move the cursor to row 24, column 0
SET_IBM_CURSOR:
  MOV AH,2          ; video BIOS function number for SET CURSOR POSITION
  INT 16          ; call the BIOS to put user cursor in lower left corner
  RET


; IBM_FIX performs a fixup of a trashed screen on an IBM machine.

; COLOR_RESTORE checks to see if the debugger screen has been trashed.    If it
;   has, we restore the screen.

COLOR_RESTORE:
  PUSH DS
  MOV DS,AX,0B800
  MOV DX,03DA        ; load the port number for reading the video status
L2:            ; loop here to wait for vertical retrace
  IN AL,DX        ; input the status
  TEST AL,1        ; mask the retrace bit
  JZ L2         ; loop if we are not in vertical retrace
  CMP B[2400],'A'
  POP DS
  JE RET
IBM_FIX:
  CS PUSH VID_COPY         ; save the old VID_COPY value
  CS MOV VID_COPY,MONO_COPY  ; coerce it to MONO_COPY, to blindly copy all
  CALL REFRESH             ; refresh the screen; let the snow scatter!
  CS POP VID_COPY         ; restore the old VID_COPY value
IBM_SAVE:
IBM_RESTORE:
  RET


; MONO_COPY is the VID_COPY routine for an IBM monochrome video board.    The
;   characters occupy the lower byte of the DI-pointed words.  We can afford
;   to rewrite the entire screen on each refresh; so no special action needs to
;   be taken.  We do complicated looping to make the routine as fast as
;   possible.

MONO_COPY:
  SHR CX,1        ; is the character count odd?
  JC >L5        ; jump if yes, to special code
L1:
  SHR CX,1        ; is the character count a multiple of 4?
  JC >L6        ; jump if not, to special code
L2:            ; loop here to copy every 4 bytes
  LODSB         ; load the character from the source
  STOSW         ; output the character, with the standard attribute byte
  LODSB         ; char # 2
  STOSW
  LODSB         ; char # 3
  STOSW
  LODSB         ; char # 4
  STOSW
  LOOP L2        ; loop for the next 4 characters
  RET

L5:            ; the character count was odd
  MOVSB         ; copy the odd character to the video buffer
  INC DI        ; advance beyond the attribute byte
  JCXZ RET        ; return if count is depleted
  JMP L1        ; join even code

L6:            ; the character count is 2 mod 4
  LODSB         ; load one character
  STOSW         ; output it and the attribute-- count now 1 mod 4
  LODSB         ; load second character
  STOSW         ; output it-- count now 0 mod 4
  JCXZ RET        ; return if count is depleted
  JMP L2        ; join multiple-of-4 code


; COLOR_COPY is the VID_COPY routine for an IBM Color Graphics Adapter board.
;   The characters occupy the lower byte of the DI-pointed words. We must wait
;   for vertical retrace to output our data, to avoid annying "snow" on the
;   screen.  So we can't afford to output the entire buffer every time.  So we
;   maintain at [SI+81] a copy of what's already on the screen for [SI], and we
;   output only if the buffer is new.

COLOR_COPY:
  PUSH BX        ; preserve BX across the call
  MOV DX,03DA        ; load the port number for reading the video status
  SKIP2         ; skip to the LODSB instruction
L0:            ; loop here for every character that is already out there
  INC DI        ; advance the output pointer beyond the character
L1:            ; loop here after a non-matching character was stored
  INC DI        ; advance beyond the following attribute byte
  LODSB         ; fetch the next character
  MOV BL,AL        ; save the character in BL
  XCHG AL,[SI+79]   ; swap it with the already-out-there value
  CMP AL,BL        ; is the character already out there?
  LOOPE L0        ; loop if it is
  JE >L4        ; jump if the characters are exhausted
L2:            ; loop here to wait for vertical retrace
  IN AL,DX        ; input the status
  TEST AL,1        ; mask the retrace bit
  JZ L2         ; loop if we are not in vertical retrace
  MOV AL,BL        ; re-fetch the character to be output
  STOSB         ; output the character
  INC CX            ; undo the previous LOOPE's decrement of CX
  LOOP L1        ; loop to check for another output character
  INC DI        ; advance beyond the attribute byte of the last character
  POP BX        ; restore clobbered register
  RET

L4:            ; matching character was the last in the buffer
  INC DI,2        ; advance beyond the output video word
  POP BX        ; restore clobbered register
  RET


; IBM_ATTR is the VID_ATTR routine for IBM-PC compatible computers.  The
;   attribute byte is the high byte of the DI-pointed video word.

IBM_ATTR:
  INC DI        ; advance to the high, attribute byte
  STOSB         ; output the attribute code AL to the byte
  RET


; IBM_KEY is the BIOS_KEY routine for IBM_PC compatible computers.  We must
;   transform the two-byte code returned by the IBM BIOS into the single
;   code AL expected by the rest of the debugger.

IBM_KEY:
  MOV AH,0        ; function code for GET KEY
  INT 016        ; get the keystroke from the IBM BIOS
  TEST AL        ; is the return AL nonzero?
  JNZ RET        ; if yes then AL is our return code
  MOV AL,AH        ; AL is zero, so AH determines the return code
  ADD AL,080-16     ; shift the values into a range not seen directly in AL
  RET


; IBM_BELL is the BIOS_BELL routine for IBM-PC compatible computers.  We
;   output the code 07 to the BIOS's console output routine.

IBM_BELL:
  MOV AX,0E07       ; AH= console out function number; AL="BELL" control code
  INT 010        ; output BELL to the console
  RET


; NEW_KEYS reassigns the keyboard codes and the action routines for a non-
;   IBM-compatible BIOS.  We are called with CS:SI pointing to a table of
;   various new values, whose format is identical to the one given by
;   WANG_KEYS below.  The new values are plugged into the various tables
;   in the debugger, so that correct actions are taken for the non-compatible
;   machine.

NEW_KEYS:
  PUSH DS        ; preserve DS across call
  MOV DS,CS        ; point DS to our program, to read the table at SI
  MOV ES,CS        ; also point the destination segment to our program
  LODSB         ; load the first byte of the table
  MOV HELP_KEY,AL    ; first byte is the code for HELP_KEY
  LODSB         ; load the second byte
  ADD SWITCH_KEY,AL    ; byte 2 is (new-IBM) function-key-codes-difference
  MOV DI,CTRL_JUMPS+2    ; point to the control-jumps table
  MOV CX,N_FUNCS    ; load the number of function-keys in that table
L1:            ; loop here to adjust each function-key code
  ADD [DI],AL        ; add the code into the table entry
  ADD DI,3        ; advance to the next table entry
  LOOP L1        ; loop to adjust the next table entry
  MOV CL,N_CONTROL_KEYS ; load the number of subsequent keys in the table
L2:            ; loop here to plug in the new value for each key
  MOVSB         ; copy the new key code to the function table
  INC DI,2        ; advance output pointer to the next key code
  LOOP L2        ; loop to plug in the next key code
  LODSW         ; fetch the message-pointer to the name of HELP key
  MOV HELP_MSG,AX    ; plug the pointer into the messages-string
  MOV DI,BIOS_CALLS    ; point to the table of action routines
  MOV CX,N_BIOS_CALLS    ; load the count of words in action-routine-table
  REP MOVSW        ; copy the new pointers to the table
  POP DS        ; restore clobbered register
  RET



;------------------
;  WANG INTERFACE
;------------------

; Thanks to Alan Tschetter for providing the information necessary for me
;   to program this interface.

WANG_KEYS:
  DB 0E1           ; HELP key value
  DB 07F-FUNC           ; add-quantity for FUNC
L1:
  DB 0C2,0C9,0C0,0C8,0C4 ; DOWN, NEXT, UP, PREV, HOME
  DB 097,097           ; shift-F7 key, disabled Alt-F9 key
N_CONTROL_KEYS EQU $-L1

  DW HELP_HELP      ; pointer to "HELP" message, the name of Wang's HELP key

L2:
  DW WANG_COPY        ; VID_COPY routine
  DW WANG_ATTR        ; VID_ATTR routine
  DW RET        ; there is no VID_FIX necessary on the Wang
  DW WANG_BELL        ; BIOS_BELL routine
  DW WANG_KEY        ; BIOS_KEY routine
  DW RET
  DW RET
  DW 0F000        ; new value for VIDEO_SEG
  DB 0            ; normal-video attribute for the Wang PC
  DB 2            ; reverse-video attribute for the Wang PC
N_BIOS_CALLS EQU ($-L2)/2


; Other Wang keycodes:    F1--F16  80--8F
;            Prev     C8      Erase   CB
;            Insert     C6      Delete  C7
;            <---     C3      --->      C1
;            EXEC     C5
;   All the above codes add 010 for SHIFT versions.
;   NO ALT KEY!!!
;            Print     E3      Back Tab     CD
;            Cancel     E0      Shift Cancel 03


; WANG_CONFIG is the BIOS initialization routine for a Wang PC.  We copy the
;   values of WANG_KEYS to various locations, then we fetch the value of
;   ENABLE_PORT, that lets us access Wang's video memory, then we move the
;   user's cursor to the lower left corner.

L1:            ; console codes to move cursor to lower left corner
  DB 01B,'[25;1H'       ; row 25, column 1
L2 EQU $-L1        ; L2 is the count of bytes

WANG_CONFIG:
  MOV SI,WANG_KEYS      ; point to Wang's table of key codes and other values
  CALL NEW_KEYS         ; plug the new values into our program's data structures
  MOV AL,1        ; function code for GET BIOS ENVIRONMENT
  INT 088               ; sets ES to a segment where we'll find port #
  ES MOV BX,[BX+10]    ; fetch a pointer
  ES MOV AH,[BX+19]    ; use the pointer to fetch the high of the port #
  MOV AL,010        ; low of the port # is always 010
  MOV ENABLE_PORT,AX    ; store the port number
  MOV DS,CS        ; point DS to our program, for console sequence
  MOV DX,L1             ; point DX to the "go to lower left" console sequence
  MOV CX,L2        ; load the number of bytes in the sequence
  MOV BH,0              ; device number, maybe?  I don't know for sure
  MOV AL,0D             ; function number, maybe?  I don't know for sure
  INT 088               ; output escape string, user's cursor goes to lower left
  RET


; WANG_COPY is the Wang-PC version of the VID_COPY routine.  The character
;   and attribute bytes are reversed from what they are on the IBM-PC, so
;   AH and AL are swapped before and after every word output.  There are no
;   snow problems; so we can get away with copying everything every time.
;   We do need to enable the video memory, though.

WANG_COPY:
  MOV DX,ENABLE_PORT  ; fetch the port number for enabling video memory
  MOV AL,1          ; value 1 causes memory to be enabled
  OUT DX,AL          ; we can now access the video memory
L1:              ; loop here for each character to be copied
  LODSB           ; fetch the next character
  XCHG AH,AL          ; swap character into AH, attribute byte into AL
  STOSW           ; output the word to video memory
  MOV AH,AL          ; copy the attribute byte back to AH, for next char
  LOOP L1          ; loop to copy the next character
L2:              ; common exit with WANG_ATTR
  MOV AL,0          ; value 0 shuts off access to video memory
  OUT DX,AL          ; video access is now disabled
  RET


; WANG_ATTR is the Wang-PC version of the VID_ATTR routine.  The attribute
;    byte is the low byte of the DI-pointed video memory.  Also, to access it,
;    we must send the code that enables Wang video memory.

WANG_ATTR:
  PUSH AX          ; preserve the attribute code
  MOV DX,ENABLE_PORT  ; fetch the port number for enabling video memory
  MOV AL,1          ; value 1 causes memory to be enabled
  OUT DX,AL          ; we can now access the video memory
  POP AX          ; restore the attribute code
  STOSB           ; output the attribute byte to the LOW byte of video word
  JMP L2          ; join common code to disable video access


; WANG_KEY is the Wang-PC version of the BIOS_KEY routine.

WANG_KEY:
  PUSH BX          ; preserve register across call
L1:              ; loop here to wait for a key to become ready
  MOV AL,15          ; Wang BIOS function code for GET KEY STATUS
  MOV BL,2            ; another parameter for Wang BIOS - I'm not sure which
  INT 088          ; call Wang BIOS to get the status and maybe the key
  TEST AL          ; do we have a key?
  JNZ L1          ; loop if not, to try again
  XCHG AX,BX          ; we do: swap the key code into AL for return
  POP BX          ; restore clobbered register
  RET


; WANG_BELL is the Wang-PC version of the BIOS_BELL routine.

WANG_BELL:
  MOV BX,7          ; BL=7 is the BELL code; the BIOS also wants BH=0
  MOV AL,6          ; Wang BIOS function code for CONSOLE OUTPUT
  INT 088          ; output the BELL control code to the Wang console
  RET


;------------------
;  TI-PC INTERFACE
;------------------

; Thanks to David R. Cook for writing the following code.  I have reformatted
; it to look like the rest of my code, and made optimizations.

TIPC_KEYS:
  DB 0B5       ; key code for F11 - the help key
  DB 0AA-FUNC       ; F1 is code 0AB on the TI-PC
L1:
  DB 0C0       ; down-arrow key
  DB 0C1       ; no PgDn key on the TI-PC, so we use alt-down-arrow code
  DB 0B8       ; up-arrow key
  DB 0B9       ; no PgUp key on the TI-PC, so we use alt-up-arrow code
  DB 0B7       ; HOME key
  DB 0CA       ; shift-F7 key
  DB 0E0       ; alt-F9 key
N_CONTROL_KEYS equ $-L1

  DW F11_HELP       ; pointer to help message

L2:
  DW TIPC_COPY        ; VID_COPY routine
  DW TIPC_ATTR        ; VID_ATTR routine
  DW TIPC_FIX        ; VID_FIX routine
  DW TIPC_BELL        ; BIOS_BELL routine
  DW TIPC_KEY        ; BIOS_KEY routine
  DW RET
  DW RET
  DW 0DE00        ; new value for VIDEO_SEG
  DB 0F         ; normal-video attribute for the TI-PC
  DB 01F        ; reverse-video attribute for the TI-PC
N_BIOS_CALLS equ ($-L2)/2

; Other TI keycodes:

;   key   +shift  +alt      +ctrl  plain
;   ----------------------------------
;   F1      0C4      0D8      0CE     0AB
;   ...
;   F10   0CD      0E1      0D7     0B4
;   F11   "x"     "|"     "z"    0B5
;   F12   "y"     "}"     "{"    0B6
;
;   PRNT             0E2
;   INS   098      09A      099     0C2
;   DEL   0A8      0AA      0A9     0C3
;   UP AR 0F8      0B9      0F4
;   DN AR 0F9      0C1      0E6
;   LT AR 0FB      0BC      0E3     0BB
;   RT AR 0FA      0BE      0E4     0BD
;   HOME  0F6      0F5      0E7
;   TAB   07F    ignored ignored   09



; TIPC_CONFIG is the BIOS initialization routine for the TI-PC.  We copy the
;   values in TIPC_KEYS to various locations, then we drop into TIPC_FIX,
;   to reset the cursor.

TIPC_CONFIG:
  MOV SI,TIPC_KEYS      ; point to configuration-table for TI-PC's BIOS
  CALL NEW_KEYS     ; copy the values to our tables
TIPC_FIX:
  MOV AH,014            ; BIOS function code for "clear graphics screen"
  INT 049        ; clear the graphics screen
  MOV AH,013            ; BIOS function code for "clear text screen"
  INT 049        ; clear the text screen
  MOV AH,2              ; BIOS function code for "position the cursor"
  MOV DX,1 BY 24    ; first column, 24th row
  INT 049               ; move the user's cursor to the bottom left corner
  RET


; TIPC_COPY is the VID_COPY routine for the TIPC video board.  The attribute
;   AH is written to a single memory-mapped latch in the video segment.
;   Then the text bytes can be copied as-is.

TIPC_COPY:
  ES MOV B[01801],AH    ; set the attribute latch
  SHR DI,1        ; adjust the video address for bytes, not words
  REP MOVSB        ; copy the text as-is
  SHL DI,1        ; restore the video address to words, not bytes
  RET


; TIPC_ATTR is the VID_ATTR routine for TI-PC computer.  We change the
;   attribute latch to the one provided in AL, then we add 0 to the video
;   character in memory, causing the new latch value to take effect.

TIPC_ATTR:
  SHR DI,1        ; adjust video address for bytes, not words
  ES MOV AH,B[DI]    ; fetch the character
  ES MOV B[01801],AL    ; rewrite the latch with the caller's value
  ES MOV B[DI],AH    ; re-write the value already there, to effect the latch
  SHL DI,1        ; restore DI
  RET


; TIPC_KEY is the BIOS_KEY routine for TI_PC computer.    We must transform the
;   two-byte code returned by the TIPC BIOS into the single code AL expected by
;   the rest of the debugger. The only differences to IBM_KEY are the interrupt
;   number, and the mapping of the codes received and returned.

TIPC_KEY:
  MOV AH,0        ; function code for GET KEY
  INT 04A        ; get the keystroke from the TIPC BIOS
  TEST AL        ; is the return AL nonzero?
  JNZ RET        ; if yes then AL is our return code
  MOV AL,AH        ; AL is zero, so AH determines the return code
  ADD AL,080-16     ; shift the values into a range not seen directly in AL
  RET


; TIPC_BELL is the BIOS_BELL routine for TIPC-PC computer.  We output the code
;   07 to the BIOS's console output routine. The only difference to IBM_KEY is
;   the interrupt number.

TIPC_BELL:
  MOV AX,0E07       ; AH= console out function number; AL="BELL" control code
  INT 049        ; output BELL to the console
  RET


;------------------
; SANYO INTERFACE
;------------------

; Thanks to Jerry Farnsworth for providing the information necessary for me
;   to program this interface.

SANYO_KEYS:
  DB 0DC       ; key code for Ctrl-PF5 -- the help key
  DB 0           ; same function codes as IBM-PC
L1:
  DB 0C0       ; down-arrow key
  DB 0C1       ; PgDn key
  DB 0B8       ; up-arrow key
  DB 0B9       ; PgUp key
  DB 0B7       ; HOME key
  DB 0CA       ; shift-F7 key is Ctrl 7 on the Sanyo
  DB ALT_F 9       ; Ctrl-Shift-PF4 will restore a trashed screen
N_CONTROL_KEYS equ $-L1

  DW PF5_HELP       ; pointer to help message

L2:
  DW SANYO_COPY     ; VID_COPY routine
  DW SANYO_ATTR     ; VID_ATTR routine
  DW SANYO_FIX        ; VID_FIX routine
  DW IBM_BELL        ; BIOS_BELL routine
  DW IBM_KEY        ; BIOS_KEY routine
  DW SANYO_SAVE     ; we must save the BIOS cursor position
  DW SANYO_RESTORE  ; we must restore the BIOS cursor position
  DW 07C00        ; new value for VIDEO_SEG
  DB 07         ; normal-video attribute for the Sanyo-PC
  DB 0F0        ; reverse-video attribute for the Sanyo-PC
N_BIOS_CALLS equ ($-L2)/2


; Other Sanyo keycodes:

; IBM         Sanyo           IBM          Sanyo

; Alt         Ctrl Shift        DOWN       numeric pad 5
; Alt Fn     Ctrl Fn           END          numeric pad 2
; Shift Fn   Ctrl n
; Ctrl 2     Ctrl `                Ctrl F12345    Ctrl ={}:"
; Ctrl 6     Ctrl tilde            Ctrl F678910   Ctrl ;',./



; SANYO_CONFIG is the BIOS initialization routine for a Sanyo 55x.  We copy the
;   values of SANYO_KEYS to various locations, fetch and store the current
;   video page, and set the user cursor to the lower left of the screen.

; SANYO_FIX insures a screen refresh by filling the "actual" buffers of SCREEN_P
;   with impossible FF-values.

SANYO_CONFIG:
  MOV SI,SANYO_KEYS     ; point to configuration-table for SANYO's BIOS
  CALL NEW_KEYS     ; copy the values to our tables
  MOV AH,15        ; function number for fetching the video page
  INT 010        ; set BH to the current video page
  CS MOV SANYO_PAGE,BH    ; store the page throughout the debugging session
  MOV DX,24 BY 0    ; load coordinates for the lower left corner
  CALL SET_SANYO_POS    ; store this position
  CALL SANYO_RESTORE    ; this call causes the user cursor to move there
SANYO_FIX:
NO_ACTUAL:
  MOV AX,0FFFF        ; load AH and AL with the 0FF impossible-value
FILL_ACTUAL:
  MOV ES,SS        ; destination segment is our stack, for buffer-fill
  MOV DI,SCREEN_P+80    ; point to the actual-buffer for the first line
  MOV DL,24        ; load the count of actual lines to fill
L2:
  MOV CX,40        ; number of words in the actual buffer
  REP STOSW        ; fill the buffer with the words
  ADD DI,256-80         ; advance output pointer to the next line's actual buff.
  DEC DL        ; count down lines
  JNZ L2        ; loop to fill the next line
  RET


; SANYO_COPY is the VID_COPY routine for the Sanyo.  The Sanyo does not have
;   a hardware character generator, so we call the BIOS to copy bit-patterns
;   to the screen.

SANYO_COPY:
  MOV AX,DI        ; fetch the output character number
  ADD DI,CX        ; add the character count
  ADD DI,CX        ; add it twice, to advance by words not bytes
  PUSH BX,DI            ; preserve caller's BX and return DI value
  MOV BH,0        ; load the page number
SANYO_PAGE EQU B[$-1]    ; previous immediate value is plugged in
  CALL GET_ROWCOL    ; convert character number AX into row-and-column DX
  DEC DX        ; cancel the following first INC DX
L1:            ; loop here for every character already out there
  INC DX        ; advance the column number DL to the next position
  LODSB         ; fetch the next character
  MOV BL,AL        ; save the character in BL
  XCHG AL,[SI+79]    ; swap it with the already-out-there value
  CMP AL,BL        ; is the character already out there?
  LOOPE L1        ; loop if it is
  JE >L2        ; jump if the characters are exhausted
  INC CX                ; undo the previous LOOPE's decrement of CX
  CALL SET_IBM_CURSOR    ; move the cursor to the indicated position
  MOV AL,BL        ; fetch the character to be output
  MOV BL,7              ; load the attribute code, always 7 in Sanyo's case
  PUSH CX        ; save the character count
  MOV CX,1        ; we are outputting 1 character in this call
  MOV AH,9        ; BIOS function number for WRITE_CHAR
  INT 010        ; write the character to the screen
  POP CX        ; restore the character count
  LOOP L1        ; loop to check for another output character
L2:
  POP DI,BX        ; restore clobbered registers
  RET


; SANYO_ATTR is the VID_ATTR routine for the Sanyo.  We use the BIOS to
;   move the cursor to the current position, read the character that is
;   already there, and rewrite the character with the new attribute.

SANYO_ATTR:
  PUSH BX,CX,DX,DI    ; save registers across call
  PUSH AX        ; save the attribute across the repositioning
  MOV AX,DI        ; fetch the character number
  CALL GET_ROWCOL    ; convert the character number AX to row-and-column DX
  CS MOV BH,SANYO_PAGE    ; load the current page number
  CALL SET_IBM_CURSOR    ; move the cursor to the required location
  MOV AH,8        ; function number for READ_CHARACTER
  INT 010        ; set AL to the character already there
  POP DX        ; restore DL = new attribute byte
  MOV BL,DL        ; copy the attribute to BL where the BIOS expects it
  MOV CX,1        ; we are writing one character only
  MOV AH,9        ; BIOS function number for WRITE_CHAR
  INT 010        ; write the character to the screen
  POP DI,DX,CX,BX    ; restore clobbered registers
  RET


; GET_ROWCOL an address AX into a row number DH and column number DL.  The input
;   AX address is twice the number of characters from the start of the screen
;   to the current cursor position.

GET_ROWCOL:
  MOV DI,160        ; each line advances the address by 160
  SUB DX,DX        ; the upper word of the dividend DXAX is always 0
  DIV DI        ; convert the address to row AX, column DL*2
  MOV DH,AL        ; the row is returned in DH
  SHR DL,1        ; the column is returned in DL
  RET


; SANYO_SAVE is the BIOS_SAVE routine for the Sanyo.  We record the user's
;   cursor position, so that it can be restored by BIOS_RESTORE.

SANYO_SAVE:
  MOV AH,3        ; BIOS function number for READ_CURSOR_POSITION
  INT 010        ; set DX to the current user cursor position
SET_SANYO_POS:
  CS MOV SANYO_POS,DX    ; store the cursor position DX
  RET


; SANYO_RESTORE is the BIOS_RESTORE routine for the Sanyo.  We set the
;   user's sursor position to the place previously stored.

SANYO_RESTORE:
  MOV DX,0        ; fetch the cursor position
SANYO_POS EQU W[$-2]    ; the above immedaite operand has been plugged
  JMP SET_IBM_CURSOR    ; jump to set the user's cursor


;------------------------
;  TANDY 2000 INTERFACE
;------------------------

; Thanks to John B. Harrell, Contributing Editor PC Resuorce, for writing
;    the following code.  I have made minor code optimizations.

TANDY_KEYS:
  DB ALT_F 10        ; code for Alt-F10 -- the HELP key
  DB 0            ; F1 code same as on IBM-PC
L1:
  DB 0C0        ; Down Arrow
  DB 0C1        ; PgDn
  DB 0B8        ; Up Arrow
  DB 0B9        ; PgUp
  DB 0B7        ; Home
  DB 0CA        ; Shift F7
  DB ALT_F 9        ; Alt-F9 fixes a trashed screen
N_CONTROL_KEYS EQU $-L1

  DW ALTF10_HELP    ; pointer to help message

L2:
  DW MONO_COPY        ; VID_COPY routine
  DW IBM_ATTR        ; VID_ATTR routine
  DW TANDY_FIX        ; VID_FIX routine
  DW IBM_BELL        ; BIOS_BELL routine
  DW IBM_KEY        ; BIOS_KEY routine
  DW RET        ; BIOS_SAVE routine needed for Sanyo only
  DW RET        ; BIOS_RESTORE routine needed for Sanyo only
TANDY_VSEG  DW ?    ; Tandy 2000 floating video segment address = VIDEO_SEG
  DB 0A         ; normal video attribute on Tandy 2000
  DB 0CA        ; reverse video attribute on Tandy 2000
N_BIOS_CALLS EQU ($-L2)/2

; Other Tandy 2000 keycodes:

;   key   +shift  +alt      +ctrl  plain
;   ----------------------------------
;   F1      0C4      0D8      0CE     0AB
;   ...
;   F10   0CD      0E1      0D7     0B4
;   F11   012     "&"     01C    008
;   F12   013     "`"     01D    009
;
;   PRNT  ---      0B6      0E2     010
;   INS   0F9      010      00F     0C2
;   DEL   0FA      00E      00D     0C3
;   UP AR 0F5      001      000
;   DN AR 0F6      007      006
;   LT AR 0F7      002      0E3     0BB
;   RT AR 0F8      ---      0E4     0BD
;   HOME  0BA      016      0E7
;   TAB   07F      0FE      0FD     009
;   BKSP  008      0FC      07F     008
;   TAB   07F      0FE      0FD     009
;   ESC   01B      0FB      01B     01B
;   END   ---      ---      0E5     0BF
;   PGUP  ---      ---      0F4     0B9
;   PGDN  ---      ---      0E6

TANDY_CONFIG:
  INT 012           ; get reported memory size in KBytes
  MOV CL,6           ; shift count = * 64 for Kbytes to paragraphs
  SHL AX,CL           ; convert to paragraphs
  ADD AX,0080           ; point to starting location of monochrome video buffer
  CS MOV TANDY_VSEG,AX ; save in data structure
  MOV SI,TANDY_KEYS    ; point to configuration table for Tandy 2000
  CALL NEW_KEYS        ; copy the value into BIOS tables
TANDY_FIX:
  MOV AX,0 BY 2        ; AH= BIOS function code for SET_VIDEO_MODE; AL = mode 0
  INT 16           ; force a monochrome video mode
  JMP SET_IBM_LOW_LEFT ; move the cursor to the lower left corner